# matplotlib retina display
%config InlineBackend.figure_format='retina'

import wfdb
import numpy as np
import matplotlib.pyplot as plt

from statsmodels.graphics.tsaplots import plot_acf
from statsmodels.tsa.stattools import ccf
import cv2
from skimage import io 

from skimage.morphology import remove_small_objects, dilation
from scipy.ndimage import binary_fill_holes
from skimage.morphology import square, skeletonize
from skimage.measure import label, regionprops

from matplotlib.patches import Patch

import time

# Path to the ECG file (excluding the extension which wfdb handles)
ecg_file_path = 'data/ecg-id-database-1.0.0/Person_08/rec_1'

# Reading the record
record = wfdb.rdrecord(ecg_file_path)

# Extracting signals and annotations
ecg_signals = record.p_signal
annotations = wfdb.rdann(ecg_file_path, 'atr')

plt.figure(figsize=(12, 6))
for i, channel in enumerate(ecg_signals.T):
    plt.subplot(len(ecg_signals.T), 1, i+1)
    plt.plot(channel)
    plt.title(f'ECG Channel {i+1}')
    plt.xlabel('Sample')
    plt.ylabel('Amplitude (mV)')
    plt.xticks(np.arange(0, len(channel)+1, 1000))
plt.tight_layout()
plt.show()

ecg_signal = record.p_signal[:,1]

ecg_signal_subset = ecg_signal[:1300] 


fig, axs = plt.subplots(2, 1, figsize=(12, 9))

# Plot the original signal
axs[0].plot(ecg_signal_subset)
axs[0].set_title('Original Signal (First 1300 Samples)')
axs[0].set_xlabel('Sample')
axs[0].set_ylabel('Amplitude (mV)')
axs[0].set_xticks(np.arange(0, len(ecg_signal_subset)+1, 50))

# Auto-correlation
plot_acf(ecg_signal_subset, lags=len(ecg_signal_subset)-1, ax=axs[1], adjusted=True)
axs[1].set_title('Auto-Correlogram')
axs[1].set_xlabel('Lag')
axs[1].set_ylabel('Correlation')
axs[1].set_xticks(np.arange(0, len(ecg_signal_subset)+1, 50))


plt.tight_layout()
plt.show()

def perform_time_lag_cross_correlation(signal, segment):
    # Time Lag Correlation (ccf) backward 
    ccf_correlation = ccf(segment, signal, adjusted=False)
    lags_ccf = np.arange(len(ccf_correlation))

    ccf_correlation = ccf_correlation / np.max(ccf_correlation)

    # ChatGPT and https://scicoding.com/cross-correlation-in-python-3-popular-packages/
    # Notice that, similarly to the SciPy implementation, we needed to remove the padding. Also, Statsmodels provides the cross-correlation response in reversed order with respect to the other schemes, which is why we needed to flip the result.
    return lags_ccf, ccf_correlation[0:(len(signal)+1)][::-1]


def plot_segment_and_time_lag_correlation(ecg_signal, segment, segment_start, title_suffix):
    segment_end = segment_start + len(segment)
    full_length_segment = np.zeros_like(ecg_signal)
    full_length_segment[segment_start:segment_end] = segment

    fig, axs = plt.subplots(3, 1, figsize=(15, 15))
    
    axs[0].plot(ecg_signal, label='Original Signal')
    axs[0].set_title("Original ECG Signal")
    axs[0].set_xlabel("Sample Index")
    axs[0].set_ylabel("Signal Amplitude")
    axs[0].legend()
    axs[0].set_xticks(np.arange(0, len(ecg_signal)+1, 500))

    # Store the y-axis limits of the original signal plot
    y_limits = axs[0].get_ylim()

    axs[1].plot(full_length_segment, label='Segmented Signal', color='orange')
    axs[1].set_title(f"Segmented Signal Aligned with Original (Segment {title_suffix})")
    axs[1].set_xlabel("Sample Index")
    axs[1].set_ylabel("Signal Amplitude")
    axs[1].legend()
    # Setting the y-axis limits to be the same as the original signal plot
    axs[1].set_ylim(y_limits)
    axs[1].set_xticks(np.arange(0, len(ecg_signal)+1, 500))

    # Performing time lag cross-correlation
    lags_ccf, ccf_correlation = perform_time_lag_cross_correlation(ecg_signal, segment)

    # Plotting time lag correlation
    axs[2].plot(ccf_correlation, color='green')
    axs[2].set_title(f'Time Lag Correlation for Segment {title_suffix}\n Peak Correlation Lag {np.argmax(ccf_correlation)} \n Peak Correlation Score {np.max(ccf_correlation):.2f}\n Lowest Correlation Lag {np.argmin(ccf_correlation)} \n Lowest Correlation Score {np.min(ccf_correlation):.2f}')
    axs[2].set_xlabel('Lags')
    axs[2].set_ylabel('Correlation')
    axs[2].set_xticks(np.arange(0, len(ecg_signal)+1, 500))
    axs[2].set_ylim([-1, 1])
    
    # set vertical line at lag with highest correlations 
    axs[2].axvline(x=np.argmax(ccf_correlation), color='red', linestyle='--')
    # set vertical line for the lowest correlation
    axs[2].axvline(x=np.argmin(ccf_correlation), color='blue', linestyle='--')

    plt.tight_layout()
    plt.show()


def add_noise(segment, noise_level):
    noise = np.random.normal(0, noise_level, segment.shape)
    return segment + noise

def scale_amplitude(segment, scale_factor):
    return segment * scale_factor

def time_shift(segment, shift):
    return np.roll(segment, shift)

def invert_signal(segment):
    return -segment


ecg_signal_subset = ecg_signal[:10000]

segment_1 = ecg_signal[0:350]
segment_2 = ecg_signal[0:1000]

plot_segment_and_time_lag_correlation(ecg_signal_subset, segment_1, 0, "0-350")

plot_segment_and_time_lag_correlation(ecg_signal_subset, segment_2, 0, "0-1250")

# Extracting a segment and adding noise
noisy_segment = add_noise(segment_1, noise_level=0.3)

# Plotting the original and noisy segments
plot_segment_and_time_lag_correlation(ecg_signal_subset, noisy_segment, 0, "Noisy 0-350")

# Extracting a segment and adding scaling
scaled_segment = scale_amplitude(segment_1, scale_factor=20)

# Plotting the original and noisy segments
plot_segment_and_time_lag_correlation(ecg_signal_subset, scaled_segment, 0, "Scaled 0-350")

# Extracting a segment and adding time shift
shifted_segment = time_shift(segment_1, shift=100)

plot_segment_and_time_lag_correlation(ecg_signal_subset, shifted_segment, 0, "Time Shifted 0-350")

# Extracting a segment and inverting
inverted_segment = invert_signal(segment_1)

plot_segment_and_time_lag_correlation(ecg_signal_subset, inverted_segment, 0, "Inverted 0-350")

original_image = io.imread('data/Roofs_Satellite.jpg')

gray_image = cv2.cvtColor(original_image, cv2.COLOR_RGB2GRAY)

plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.imshow(original_image)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(gray_image, cmap='gray')
plt.title('Grayscale Image')
plt.axis('off')

plt.show()

# Convert to HSV color space
hsv_image = cv2.cvtColor(original_image, cv2.COLOR_RGB2HSV)

# Define color ranges for red and brown
lower_red1 = np.array([0, 50, 20])
upper_red1 = np.array([10, 255, 255])
lower_brown = np.array([10, 50, 20])
upper_brown = np.array([15, 255, 255])
lower_red2 = np.array([160, 50, 20])
upper_red2 = np.array([180, 255, 255])

mask1 = cv2.inRange(hsv_image, lower_red1, upper_red1)
mask2 = cv2.inRange(hsv_image, lower_brown, upper_brown)
mask3 = cv2.inRange(hsv_image, lower_red2, upper_red2)

# Combine masks to capture red and brown shades
combined_mask = mask1 + mask2 + mask3

# Plot the initial combined mask
plt.figure(figsize=(6, 6))
plt.imshow(combined_mask, cmap='gray')
plt.title('Initial Combined Mask')
plt.axis('off')
plt.show()

# Perform morphological operations to refine the mask
kernel = np.ones((3, 3), np.uint8)
refined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_OPEN, kernel)

# Plot the refined mask
plt.figure(figsize=(6, 6))
plt.imshow(refined_mask, cmap='gray')
plt.title('Refined Mask after Opening')
plt.axis('off')
plt.show()

# Fill holes using binary_fill_holes
filled_mask = binary_fill_holes(refined_mask).astype(np.uint8)

# plot the filled mask
plt.figure(figsize=(6, 6))
plt.imshow(filled_mask, cmap='gray')
plt.title('Mask after Filling Holes')
plt.axis('off')
plt.show()

# Remove small objects from the filled mask
min_size = 6000
cleaned_mask_bool = remove_small_objects(filled_mask > 0, min_size=min_size)

# Convert boolean mask back to uint8 for visualization and further processing
cleaned_mask = (cleaned_mask_bool * 255).astype(np.uint8)

# Label and analyze properties of the closed mask
labeled_mask = label(cleaned_mask)
properties = regionprops(labeled_mask)

# Count of objects before and after filling holes
objects_before_filling = np.max(label(refined_mask))
objects_after_cleaning = len(properties)
print(f"Objects before filling holes: {objects_before_filling}")
print(f"Objects after all cleaning operations: {objects_after_cleaning}")

# Plot the mask after filling holes and removing small objects
plt.figure(figsize=(6, 6))
plt.imshow(cleaned_mask, cmap='gray')
plt.title('Mask after Removing Small Objects')
plt.axis('off')
plt.show()

Objects before filling holes: 23412
Objects after all cleaning operations: 68

# Close small holes on the roofs with a larger kernel
large_kernel = np.ones((5, 5), np.uint8)
closed_mask = cv2.morphologyEx(cleaned_mask, cv2.MORPH_CLOSE, large_kernel, iterations=5)

# Plot the mask after the closing operation
plt.figure(figsize=(6, 6))
plt.imshow(closed_mask, cmap='gray')
plt.title('Mask after Closing Operation')
plt.axis('off')
plt.show()

# fill holes again 
filled_mask_2 = binary_fill_holes(closed_mask).astype(np.uint8)

# Label and analyze properties of the closed mask
labeled_mask = label(filled_mask_2)
properties = regionprops(labeled_mask)

print(f"Count of objects: {len(properties)}")


# plot the filled mask
plt.figure(figsize=(6, 6))
plt.imshow(filled_mask_2, cmap='gray')
plt.title('Mask after Filling Holes')
plt.axis('off')
plt.show()

Count of objects: 46

areas = [prop.area for prop in properties]

# Find the largest area index
largest_area_index = np.argmax(areas)

# Skeletonize the largest area
skeleton = skeletonize(labeled_mask == largest_area_index + 1)

# Skeletonize all areas
skeleton_all = skeletonize(labeled_mask > 0)

# Dilate the skeletons for visibility
thick_skeleton_all = dilation(skeleton_all, square(10))
thick_skeleton = dilation(skeleton, square(10))

plt.figure(figsize=(8, 6))
ax = plt.gca()

# Initialize a color image with the same dimensions, all black
color_image = np.zeros((thick_skeleton_all.shape[0], thick_skeleton_all.shape[1], 3), dtype=np.uint8)

# Assign the thick skeleton of all rooftops to white
color_image[thick_skeleton_all == 1] = [255, 255, 255]

# Overlay the largest rooftop in red
color_image[thick_skeleton == 1] = [255, 0, 0]

plt.imshow(color_image)

# Create a legend and position it outside the plot
legend_elements = [Patch(facecolor='white', edgecolor='black', label='All Rooftops'),
                   Patch(facecolor='red', edgecolor='black', label='Largest Rooftop')]
plt.legend(handles=legend_elements, loc='upper left', bbox_to_anchor=(1, 1))

plt.title(f'Skeleton of all rooftops\npixel count of largest rooftop: {np.sum(skeleton)} pixels\npixel count of all rooftops: {np.sum(skeleton_all)} pixels')
plt.axis('off')
plt.tight_layout()
plt.show()

# Overlay bounding boxes on the original image
overlay_with_bboxes = original_image.copy()
for prop in properties:
    minr, minc, maxr, maxc = prop.bbox
    cv2.rectangle(overlay_with_bboxes, (minc, minr), (maxc, maxr), (0, 255, 0), 3)

# Overlay the skeleton on the original image
skeleton_overlay = original_image.copy()

# change the color of the skeleton to blue to make it more visible
skeleton_overlay[thick_skeleton_all] = [0, 0, 255] 

titles = ['Original Image', 'Combined Mask', 'Refined Mask', 'Filled Mask',
          'Cleaned Mask', 'Closed Mask', 'Refilled Mask', 'All Skeletons', 'Skeleton Overlay', 'Bounding Boxes']
images = [original_image, combined_mask, refined_mask, filled_mask,
          cleaned_mask, closed_mask, filled_mask_2 , thick_skeleton_all, skeleton_overlay, overlay_with_bboxes]

plt.figure(figsize=(18, 14))
for i in range(len(titles)):
    plt.subplot(2, 5, i + 1)
    if titles[i] == 'Skeleton Overlay':
        plt.imshow(images[i])
    else:
        plt.imshow(images[i], cmap='gray' if i > 1 else None)
    plt.title(titles[i])
    plt.axis('off')
plt.tight_layout()
plt.show()

# Define the final mask as the result of the last operations in the user's code
final_mask = filled_mask_2

# Apply the final mask to the original image to create a segmented image
segmented_image = cv2.bitwise_and(original_image, original_image, mask=final_mask)

# Display the original and segmented images
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.imshow(original_image)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(segmented_image)
plt.title('Segmented Image')
plt.axis('off')

plt.show()

# Assuming 'properties' is a list of properties for each region
properties = regionprops(labeled_mask)

areas = [prop.area for prop in properties]
perimeters = [prop.perimeter for prop in properties]
eccentricities = [prop.eccentricity for prop in properties]

metrics = {
    'Area': (np.mean(areas), np.median(areas)),
    'Perimeter': (np.mean(perimeters), np.median(perimeters)),
    'Eccentricity': (np.mean(eccentricities), np.median(eccentricities))
}

def plot_histogram(data, title, x_label, color, ax):
    mean_val, median_val = metrics[title]
    ax.hist(data, bins=20, color=color, alpha=0.7, edgecolor='black')
    ax.set_title(f'Histogram of Rooftop {title}\nTotal Rooftops: {len(data)}')
    ax.set_xlabel(x_label)
    ax.set_ylabel('Frequency')
    ax.axvline(mean_val, color='orange', linestyle='dashed', linewidth=2, label=f'Mean: {mean_val:.2f}')
    ax.axvline(median_val, color='red', linestyle='dashed', linewidth=2, label=f'Median: {median_val:.2f}')
    ax.legend()
    ax.grid(True)

fig, axs = plt.subplots(1, 3, figsize=(18, 6))

plot_histogram(areas, 'Area', 'Area (pixels)', 'blue', axs[0])
plot_histogram(perimeters, 'Perimeter', 'Perimeter (pixels)', 'green', axs[1])
plot_histogram(eccentricities, 'Eccentricity', 'Eccentricity', 'red', axs[2])

plt.tight_layout()
plt.show()

largest_properties = sorted(properties, key=lambda x: x.area, reverse=True)[:5]

fig, axs = plt.subplots(1, 5, figsize=(20, 4))
for i, prop in enumerate(largest_properties):
    minr, minc, maxr, maxc = prop.bbox
    
    # Mask and crop the rooftop
    rooftop_mask = labeled_mask == prop.label
    cropped_mask = rooftop_mask[minr:maxr, minc:maxc]
    rooftop_image = original_image[minr:maxr, minc:maxc]
    masked_rooftop = np.where(cropped_mask[..., None], rooftop_image, 0)

    area = prop.area
    perimeter = prop.perimeter
    eccentricity = prop.eccentricity
    stats_title = f'Rooftop {i+1} \nArea: {area}\n Perimeter: {perimeter:.2f}\n Eccentricity: {eccentricity:.2f}'

    axs[i].imshow(masked_rooftop)
    axs[i].set_title(stats_title)
    axs[i].axis('off')

plt.show()

def adjust_brightness(image, brightness_offset):
    """
    Adjusts the brightness of an image.
    """
    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
    h, s, v = cv2.split(hsv)
    v = np.clip(np.int16(v) + brightness_offset, 0, 255).astype(np.uint8)
    final_hsv = cv2.merge((h, s, v))
    return cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)


def flip_image(image, flip_code):
    """
    Flips an image.
    """
    return cv2.flip(image, flip_code)

def rotate_image(image, angle):
    """
    Rotates an image.
    """
    height, width = image.shape[:2]
    rotation_matrix = cv2.getRotationMatrix2D((width / 2, height / 2), angle, 1)
    return cv2.warpAffine(image, rotation_matrix, (width, height))

def crop_center(img, crop_width, crop_height):
    """
    Crops the center of the image.
    """
    center_x, center_y = img.shape[1] // 2, img.shape[0] // 2
    start_x = max(center_x - crop_width // 2, 0)
    start_y = max(center_y - crop_height // 2, 0)
    end_x = start_x + crop_width
    end_y = start_y + crop_height
    return img[start_y:end_y, start_x:end_x]

def load_image(path):
    """
    Loads an image from a file path.
    """
    img = cv2.imread(path, cv2.IMREAD_COLOR)
    if img is None:
        raise FileNotFoundError(f"Failed to load image from {path}")
    return img

def plot_images(images, titles, figsize=(15, 10)):
    """
    Plots a list of images.
    """
    plt.figure(figsize=figsize)
    for i, (img, title) in enumerate(zip(images, titles)):
        plt.subplot(2, 4, i + 1)
        plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        plt.title(title)
        plt.axis('off')
    plt.tight_layout()
    plt.show()

crop_size = (850, 750)

# Load images
main_image_path = 'data/Warframe/main.jpg'
main_image = load_image(main_image_path)
main_image = crop_center(main_image, *crop_size)

bright_image = adjust_brightness(main_image, 100)
dimmed_image = adjust_brightness(main_image, -100)

flip_image = flip_image(main_image, 1)
rotate_image = rotate_image(main_image, 70)

angled_image = load_image('data/Warframe/angled1.jpg')
angled_image = crop_center(angled_image, *crop_size)

lightning_image = load_image('data/Warframe/lightning.jpg')
lightning_image = crop_center(lightning_image, *crop_size)

far_image = load_image('data/Warframe/far.jpg')
far_image = crop_center(far_image, *crop_size)

# Crop all images
cropped_images = [main_image, angled_image, bright_image, dimmed_image, lightning_image, far_image, flip_image, rotate_image]

titles = ['Main', 'Angled', 'Bright', 'Dimmed', 'Lightning', 'Far', 'Flipped', 'Rotated']

plot_images(cropped_images, titles)

class KeypointMatcher:
    def __init__(self, sift_params=None):
        if sift_params is None:
            sift_params = {'nfeatures': 1200, 'contrastThreshold': 0.03, 'edgeThreshold': 10, 'sigma': 1.2}
        self.sift = cv2.SIFT_create(**sift_params)

    def ensure_grayscale(self, image):
        if len(image.shape) == 3:
            return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        return image

    def detect_and_compute(self, image):
        gray_image = self.ensure_grayscale(image)
        keypoints, descriptors = self.sift.detectAndCompute(gray_image, None)
        return keypoints, descriptors

    def match_keypoints(self, descriptors1, descriptors2, ratio_test=0.75):
        bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False)
        matches = bf.knnMatch(descriptors1, descriptors2, k=2)
        good_matches = [m for m, n in matches if m.distance < ratio_test * n.distance]
        return sorted(good_matches, key=lambda x: x.distance)

    def draw_matches(self, img1, kp1, img2, kp2, matches):
        matched_image = cv2.drawMatches(img1, kp1, img2, kp2, matches, None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
        return cv2.cvtColor(matched_image, cv2.COLOR_BGR2RGB)

    def run_test(self, main_image, test_image, test_name, plot_matches=True, n_matches=10):
        kp_main, des_main = self.detect_and_compute(main_image)
        kp_test, des_test = self.detect_and_compute(test_image)
        good_matches = self.match_keypoints(des_main, des_test)

        if plot_matches:
            matched_image = self.draw_matches(main_image, kp_main, test_image, kp_test, good_matches[:n_matches])
            plt.figure(figsize=(12, 6))
            plt.imshow(matched_image)
            plt.axis('off')
            plt.title(f'{test_name} - Matched Keypoints\n Good Matches: {len(good_matches)} (Showing the best {n_matches})')
            plt.show()
        else:
            return good_matches


class KeypointMatcherOptimizer:
    def __init__(self, main_image, test_images):
        self.main_image = main_image
        self.test_images = test_images

    def run_range_optimization(self, parameter_ranges):
        parameter_scores = {param: [] for param in parameter_ranges}

        for param, (start, end, step) in parameter_ranges.items():
            for value in np.arange(start, end, step):
                sift_params = {p: value if p == param else next(iter(parameter_ranges[p])) for p in parameter_ranges}
                score = self.test_sift_params(sift_params)
                parameter_scores[param].append((value, score))

        return parameter_scores

    def test_sift_params(self, sift_params):
        matcher = KeypointMatcher(sift_params)
        total_good_matches = 0
        total_time_taken = 0

        for test_image in self.test_images:
            start_time = time.time()
            good_matches = matcher.run_test(self.main_image, test_image, test_name="", plot_matches=False)
            end_time = time.time()

            total_good_matches += len(good_matches)
            total_time_taken += end_time - start_time

        avg_good_matches = total_good_matches / len(self.test_images)
        avg_time_taken = total_time_taken / len(self.test_images)
        return avg_good_matches, avg_time_taken

# we are optimizing for the more problematic images as the other ones seem to be fine no matter what parameters we use
test_images = [angled_image, far_image, lightning_image]

# Define parameter ranges for optimization, contrastThreshold will be ignored as it had no impact on the results.
# I tested with bigger ranges but these ranges are representative of my thought process in decision making and take less time to run.
parameter_ranges = {
    'nfeatures': (500, 10000, 500),
    'edgeThreshold': (5, 50, 5), 
    'sigma': (1.0, 8.0, 0.2)
}

# Run optimization
optimizer = KeypointMatcherOptimizer(main_image, test_images)
parameter_scores = optimizer.run_range_optimization(parameter_ranges)

for param, scores in parameter_scores.items():
    values, matches_time_pairs = zip(*scores)
    matches, times = zip(*matches_time_pairs)

    fig, ax1 = plt.subplots()

    ax1.plot(values, matches, 'b-o')
    ax1.set_xlabel(param)
    ax1.set_ylabel('Average Good Matches', color='b')
    ax1.tick_params('y', colors='b')

    ax2 = ax1.twinx()
    ax2.plot(values, times, 'r-o')
    ax2.set_ylabel('Average Time Taken (seconds)', color='r')
    ax2.tick_params('y', colors='r')
    ax2.set_ylim(0, 1)

    plt.title(f'Impact of {param} on Performance and Efficiency')
    plt.grid(True)
    plt.show()

# print best parameter values to be sure.
print(parameter_scores['nfeatures'][9][0])
print(parameter_scores['edgeThreshold'][4][0])
print(parameter_scores['sigma'][6][0])

5000
25
2.1999999999999997

sift_params = {
    'nfeatures': 5000,
    'edgeThreshold': 25,
    'sigma': 2.2
}

matcher = KeypointMatcher(sift_params)

matcher.run_test(main_image, angled_image, 'Main vs Angled', n_matches=20)

matcher.run_test(main_image, bright_image, 'Main vs Bright', n_matches=20)

matcher.run_test(main_image, dimmed_image, 'Main vs Dimmed', n_matches=20)

matcher.run_test(main_image, lightning_image, 'Main vs Lightning', n_matches=20)

matcher.run_test(main_image, far_image, 'Main vs Far', n_matches=20)

matcher.run_test(main_image, flip_image, 'Main vs Flipped', n_matches=20)

matcher.run_test(main_image, rotate_image, 'Main vs Rotated', n_matches=20)

1. Introduction¶

1.1. Overview¶

1.2. Objective¶

1.3. Approach and Dataset Diversity¶

2. Correlation in signals¶

2.1. Problem¶

2.1.1. Dataset¶

2.1.2. Approach¶

2.1.2.1. Metrics and Tools¶

2.1.3. Revised Signal Processing Steps¶

2.1.4. Explanation of the Plots¶

2.1.5. Importance of Signal Representation¶

2.2. Auto-Correlogram of the ECG Signal¶

2.3. Cross-Correlation of the ECG Signal with Segements¶

2.4. Cross-Correlation of the ECG Signal with Modified Segments¶

2.4.1. Noise¶

2.4.2. Scaling¶

2.4.3. Inversion¶

2.5. Final Conclusion¶

3. Segmentation, morphological operations, object properties in images¶

3.1. Problem¶

3.1.1. Dataset¶

3.1.2. Approach¶

3.1.2.1. Objective¶

3.1.2.2. Methodology¶

3.1.2.3. Metrics and Visualization¶

3.2. Color-based Segmentation in HSV Color Space¶

3.3. Morphological Opening to Refine the Mask¶

3.4. Filling Holes¶

3.5. Removing Small Objects¶

3.6. Closing Operation to Refine Mask¶

3.7. Fill Holes Again¶

3.8. Skeletonization for Minimal Representation¶

3.9. Labeling and Object Property Analysis¶

3.9.1. Analysis of Rooftop Properties for Solar Panel Placement¶

3.9.1.1. Area¶

3.9.1.2. Perimeter¶

3.9.1.3. Eccentricity¶

3.9.2. Consideration of Brightness for Solar Panel Placement¶

3.10. Final Conclusion¶

4. feature descriptors in images (LE4): keypoint matching¶

4.1. SIFT (Scale-Invariant Feature Transform)¶

4.1.1. What is SIFT?¶

4.1.2. How SIFT Works¶

4.1.3. Capabilities of SIFT¶

4.1.4. Limitations¶

4.2. Data Description: Warframe Images of Mirage Prime¶

4.2.1. Image Description¶

4.3. Tests Breakdown¶

4.3.1. Perspective Variation Test¶

4.3.2. Lighting Variation Test¶

4.3.3. Special Effects Test¶

4.3.4. Distance Variation Test¶

4.3.5. Horizontal Flip Test¶

4.3.6. Rotational Robustness Test¶

4.3.7. Optimizating SIFT Parameters¶

4.3.7.1. Definition of Good Matches¶

4.4. Keypoint Matching Tests¶

4.4.1. Perspective Variation Test¶

4.4.1.1. Objective¶

4.4.1.2. Expected Result¶

4.4.1.3. Analysis¶

4.4.2. Lighting Variation Test - Bright¶

4.4.2.1. Objective¶

4.4.2.2. Expected Result¶

4.4.2.3. Analysis¶

4.4.3. Lighting Variation Test - Dimmed¶

4.4.3.1. Objective¶

4.4.3.2. Expected Result¶

4.4.3.3. Analysis¶

4.4.4. Special Effects Test¶

4.4.4.1. Objective¶

4.4.4.2. Expected Result¶

4.4.4.3. Analysis¶

4.4.5. Distance Variation Test¶

4.4.5.1. Objective¶

4.4.5.2. Expected Result¶

4.4.5.3. Analysis¶

4.4.6. Horizontal Flip Test¶

4.4.6.1. Objective¶

1. Introduction ¶

1.1. Overview ¶

1.2. Objective ¶

1.3. Approach and Dataset Diversity ¶

2. Correlation in signals ¶

2.1. Problem ¶

2.1.1. Dataset ¶

2.1.2. Approach ¶

2.1.2.1. Metrics and Tools ¶

2.1.3. Revised Signal Processing Steps ¶

2.1.4. Explanation of the Plots ¶

2.1.5. Importance of Signal Representation ¶

2.2. Auto-Correlogram of the ECG Signal ¶

2.3. Cross-Correlation of the ECG Signal with Segements ¶

2.4. Cross-Correlation of the ECG Signal with Modified Segments ¶

2.4.1. Noise ¶

2.4.2. Scaling ¶

2.4.3. Inversion ¶

2.5. Final Conclusion ¶

3. Segmentation, morphological operations, object properties in images ¶

3.1. Problem ¶

3.1.1. Dataset ¶

3.1.2. Approach ¶

3.1.2.1. Objective ¶

3.1.2.2. Methodology ¶

3.1.2.3. Metrics and Visualization ¶

3.2. Color-based Segmentation in HSV Color Space ¶

3.3. Morphological Opening to Refine the Mask ¶

3.4. Filling Holes ¶

3.5. Removing Small Objects ¶

3.6. Closing Operation to Refine Mask ¶

3.7. Fill Holes Again ¶

3.8. Skeletonization for Minimal Representation ¶

3.9. Labeling and Object Property Analysis ¶

3.9.1. Analysis of Rooftop Properties for Solar Panel Placement ¶

3.9.1.1. Area ¶

3.9.1.2. Perimeter ¶

3.9.1.3. Eccentricity ¶

3.9.2. Consideration of Brightness for Solar Panel Placement ¶

3.10. Final Conclusion ¶

4. feature descriptors in images (LE4): keypoint matching ¶

4.1.2. How SIFT Works ¶

4.1.3. Capabilities of SIFT ¶

4.1.4. Limitations ¶

4.2. Data Description: Warframe Images of Mirage Prime ¶

4.2.1. Image Description ¶

4.3. Tests Breakdown ¶

4.3.1. Perspective Variation Test ¶

4.3.2. Lighting Variation Test ¶

4.3.3. Special Effects Test ¶

4.3.4. Distance Variation Test ¶

4.3.5. Horizontal Flip Test ¶

4.3.6. Rotational Robustness Test ¶

4.3.7. Optimizating SIFT Parameters ¶

4.3.7.1. Definition of Good Matches ¶

4.4. Keypoint Matching Tests ¶

4.4.1. Perspective Variation Test ¶

4.4.1.1. Objective ¶

4.4.1.2. Expected Result ¶

4.4.1.3. Analysis ¶

4.4.2. Lighting Variation Test - Bright ¶

4.4.2.1. Objective ¶

4.4.2.2. Expected Result ¶

4.4.2.3. Analysis ¶

4.4.3. Lighting Variation Test - Dimmed ¶

4.4.3.1. Objective ¶

4.4.3.2. Expected Result ¶

4.4.3.3. Analysis ¶

4.4.4. Special Effects Test ¶

4.4.4.1. Objective ¶

4.4.4.2. Expected Result ¶

4.4.4.3. Analysis ¶

4.4.5. Distance Variation Test ¶

4.4.5.1. Objective ¶

4.4.5.2. Expected Result ¶

4.4.5.3. Analysis ¶

4.4.6. Horizontal Flip Test ¶

4.4.6.1. Objective ¶

4.4.6.2. Expected Result ¶

4.4.6.3. Analysis ¶